﻿//* ==========================================================================
// Classe : Fichiers 
// Fonctions : Classe de fonctions de gestion de fichiers 
// 
// License:  License LGPL 
// Version :  0.01    du 13/07/2008 
// Lien : http://outils.codeplex.com 
// Auteur(s) : JF. PACORY
// CopyLeft: CopyLeft (>) 2008-2009 GlopSoft <contact@glopsoft.com>
// Création : 06/20/2009 17:11:31
// Etat : en cours
// Controle du :
// Licence : 
// L'autorisation est accordée, à titre gratuit, à toute personne d'obtenir une copie 
// de ce logiciel et de ses fichiers de documentation, pour pouvoir utiliser 
//ce logiciel sans restriction, y compris, sans s'y limiter, les droits 
// d'utiliser, de copier, de modifier, de fusionner, de publier, de distribuer, 
// de sous-licence, et / ou de vendre les copies du Logiciel, et d'autoriser les 
// personnes auxquelles le logiciel est livré de le faire, sous réserve des 
// conditions suivantes:
// 
// Les avis de droit d'auteur et la présente autorisation doivent être inclus dans 
// toutes les copies ou parties substantielles du Logiciel.
// 
// LE LOGICIEL EST FOURNI "TEL QUEL", SANS GARANTIE DE QUELQUE NATURE QUE CE SOIT, 
// EXPLICITE OU  IMPLICITE, Y COMPRIS, MAIS SANS Y LIMITER LES GARANTIES DE QUALITE 
// MARCHANDE, D'ADEQUATION A UN USAGE PARTICULIER ET D'ABSENCE DE CONTREFAÇON. EN 
// AUCUN CAS LES AUTEURS OU LES TITULAIRES DE DROITS D'AUTEUR POURRONT ETRE TENUE 
// RESPONSABLES DE TOUT DOMMAGE,  RÉCLAMATION OU AUTRE  RESPONSABILITE, DANS LE 
// CADRE D'UNE ACTION DE CONTRAT, UN DELIT OU AUTRE, DÉCOULANT DE, OU EN RELATION 
// AVEC LE LOGICIEL OU DE SON UTILISATION OU AUTRES EN RELATION AVEC LE LOGICIEL.
// Licence LGPL : http://commonlibrarynet.codeplex.com/license 
//*---------------------------------------------------------------------------
//
//* ==========================================================================
#region Références

using System;
using System.IO;
using System.DirectoryServices;
using System.Collections;
using System.Diagnostics;

using Outils.Constantes;
using Outils.Globale;
using Outils.DateHeure;
using Outils.Chaines;

#endregion

namespace Outils.Fichiers
{
    /// <summary>
    /// Classe de fonctions de gestion de fichiers
    /// </summary>
    public static class Fichiers
    {
        #region Attributs
        private static StreamWriter fLog;
        private static string nomFichierLog;
        private static Stopwatch chronometre;
        #endregion

        #region Propriétés

        /// <summary>
        /// Fichier journal
        /// </summary>
        public static StreamWriter FLog
        {
            get { return fLog; }
            set { fLog = value; }
        }
        /// <summary>
        /// Nom du fichier journal
        /// </summary>
        public static string NomFichierLog
        {
            get { return nomFichierLog; }
            set { nomFichierLog = value; }
        }
        /// <summary>
        /// Chronomètre d'exécution
        /// </summary>
        public static Stopwatch Chronometre
        {
            get { return chronometre; }
            set { chronometre = value; }
        }

        #endregion

        #region gestion d'un fichier journal (.log)

        #region Crée un Fichier journal : OuvreJournal 
         
        /// <summary>Crée un Fichier journal</summary>
        /// <remarks>13/07/2008</remarks>
        /// <param name="strNomJournal">Nom du fichier journal</param>
        /// <param name="strTitreJournal">Entête du fichier journal</param>        
        public static void OuvreJournal( string strNomJournal, string strTitreJournal )
        {
            try
            {
                // ouvrir le journal
                nomFichierLog = strNomJournal;

                //TODO : si le journal existe, le supprimer d'abord

                // Ouverture du fichier en mode ajout (true)
                fLog = new StreamWriter( nomFichierLog, false, System.Text.Encoding.Default, 65536 );
                chronometre = new Stopwatch();
                chronometre.Start();
                fLog.WriteLine( strTitreJournal + Constante.Crlf + "Fichier journal créé à " +
                               Date.Heure( DateTime.Now ) + " le " + Date.DatePoint( DateTime.Now ) + Constante.Crlf + Chaine.Traits() + Constante.Crlf );
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {

            }
        }
        #endregion

        #region Ecrire une ligne dans le fichier journal : EcrireLigneJournal
        
        /// <summary> Ecrire une ligne dans le fichier journal</summary>
        /// <remarks>13/07/2008</remarks>
        /// <param name="strLigne">Ligne à écrire dans le fichier journal</param>        
        public static void EcrireLigneJournal( string strLigne )
        {
            try
            {
                fLog.WriteLine( strLigne );
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {

            }
        }
        #endregion

        #region fermer le journal : FermeJournal
        
        /// <summary>fermer le journal</summary>
        /// <remarks>13/07/2008</remarks>
        /// <returns></returns>
        
        public static void FermeJournal()
        {
            try
            {
                fLog.WriteLine( Constante.Crlf + Chaine.Traits() + Constante.Crlf + "Fichier fermé à " + Date.Heure( DateTime.Now ) );
                Chronometre.Stop();
                fLog.WriteLine( "Temps écoulé : {0}", Chronometre.Elapsed );
                fLog.WriteLine( "En millisecondes : {0}", Chronometre.ElapsedMilliseconds );
                fLog.WriteLine( "En cycles : {0}", Chronometre.ElapsedTicks );
                fLog.Close();
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {

            }
        }
        #endregion

        #endregion

        /// <summary>
        /// Donne un Nom de fichier Temporaire
        /// </summary>
        /// <returns>Chaine contenant le nom du fichier aléatoire</returns>
        public static string DonneNomFichierTemp()
        {
            return System.IO.Path.GetTempFileName();
        }

        #region Fonction CompteLignes
        /// <summary>
        /// Fonction retournant le nombre de lignes du fichier passé en paramètre.
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        public static int CompteLignes( string path )
        {
            try
            {
                // création d'un streamreader sur le fichier de code
                StreamReader srFile = new StreamReader( path );
                // variable contenant la ligne courrante
                string strLine = string.Empty;

                int LiCompteur = 0;                                                     // compteur de lignes
                while ( ( strLine = srFile.ReadLine() ) != null )
                {
                    LiCompteur++;
                }
                //  ferme le streamreader
                srFile.Close();
                //  retourne le nombre de lignes de ce fichier
                return LiCompteur;
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {
            }
        }
        #endregion

        #region Transforme un fichier lue en une chaine unique
        
        /// <summary>Transforme un fichier lue en une chaine unique</summary>
        
        /// <remarks>26/06/2008</remarks>
        /// <param name="cheminFichier">chemin d acces a un fichier texte</param>
        /// <returns>chaine contenant le fichier</returns>
        
        public static string LisFichierEnChaine( string cheminFichier )
        { 
                string strTemp = string.Empty;
                using (StreamReader srFicOut = new StreamReader(cheminFichier, System.Text.Encoding.UTF8))
                {
                    strTemp = srFicOut.ReadToEnd();
                    srFicOut.Close();
                }
                return strTemp; 
        }
        #endregion

        #region Génère un listing hiérachique à partir d'un dossier root
        
        /// <summary>Génère un listing hiérachique à partir d'un dossier root</summary>
        
        /// <remarks>25/06/2008</remarks>
        /// <param name="path">string</param>
        /// <param name="strW">StreamWriter</param>
        /// <param name="count">int</param>
        /// <returns></returns>
        
        public static void Arbo( string path, StreamWriter strW, int count )
        {
            try
            {
                DirectoryInfo di = new DirectoryInfo( path );
                string tmp = string.Empty;
                for ( int i = 0; i < count; i++ ) tmp = tmp + string.Empty;
                strW.WriteLine( tmp + "<img src=data/folder.ico ><FONT class=content>" + di.Name + "</FONT><br>" );
                tmp = string.Empty;
                for ( int i = 0; i < count + 2; i++ ) tmp = tmp + string.Empty;
                foreach ( FileInfo fi in di.GetFiles() )
                {
                    strW.WriteLine( tmp + "<img src=data/file.ico ><FONT class=content>" + fi.Name + "</FONT><br>" );
                }
                foreach ( DirectoryInfo dii in di.GetDirectories() )
                {
                    Arbo( dii.FullName, strW, count + 2 ); // appel récursif avec nouveaux paramètres
                }
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {

            }
        }
        #endregion

        #region Copie d'un répertoire vers un nouveau de tous les fichiers
        
        /// <summary>Copie d'un répertoire vers un nouveau de tous les fichiers</summary>
        
        /// <remarks>25/06/2008</remarks>
        /// <param name="sourcePath"></param>
        /// <param name="destinationPath"></param>
        /// <param name="destinationFolder"></param>
        /// <returns></returns>
        
        public static void CopieRepertoireComplet( string sourcePath, string destinationPath, string destinationFolder )
        {
            try
            {
                DirectorySearcher dsRechercheDossier = new DirectorySearcher();
                DirectoryEntry deEntreeRepertoire = new DirectoryEntry();

                if ( Directory.Exists( destinationPath + destinationFolder ) )
                    Directory.Delete( destinationPath + destinationFolder, true );

                Directory.CreateDirectory( destinationPath + "\\" + destinationFolder );

                string[] fileArray = Directory.GetFiles( sourcePath );
                string fileName = null;
                for ( int i = 0; i < fileArray.Length; i++ )
                {
                    fileName = Path.GetFileName( fileArray[ i ] );
                    File.Copy( fileArray[ i ], destinationPath + "\\" + destinationFolder + "\\" + fileName, true );
                }
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {

            }
        }
        #endregion

        #region Récupère les fichiers d'un répertoire
        /// <summary>
        /// Récupère les fichiers d'un répertoire
        /// </summary>
        /// <param name="path"></param>
        /// <param name="ext"></param>
        /// <returns></returns>
        public static String[] GetFilesInDirectory( String path, String ext )
        {
            /*
			try {
				//Déclarations
				
				ArrayList lst;
				String[] tabExt = ext.Split(';');
				Int32 i, j;
				Boolean trouve;

				//On copie tous les "fichiers" du répertoire path...
				//... dans le tableau lst
				lst.AddRange(dir.GetFileSystemEntries(path));

				i = 0;
				while(i < lst.Count) {
//					 si le fichier n'a pas l'extension souhaitée...
//					 ou que c'est un répertoire alors...
//					 on supprime la ligne SANS incrémenter i...
//					 car en supprimant, on va "remonter" tous les éléments...
//					 suivant cette référence et l'élément suivant l'élément courant...
//					 n'aurait pas été traité si on aurait incrémenté i
					trouve = false;

					//Si c'est un dossier
					if(System.IO.Directory.Exists(file)) {
						//On ajoute tous les éléments de ce dossier (fichiers+répertoires)
						lst.AddRange(getFilesInDirectory((string)lst[i], ext));
					}
					else {
						//test d'extension
						j = 0;
						while(!trouve && j <= nbExt - 1) {
							//Test de l'extension
							if(lst.EndsWith("." + tabExt[j])) {
								trouve = true;
							}
							else {
								j++;
							}
						}
					}

					//S'il a pas trouvé les extensions ou que c'est un dossier... on le supprime
					if(!trouve) {
						lst.RemoveAt(i);
					}
					else {
						i ++;
					}
				}

				return lst.ToArray();
			}
			  catch ( Exception  )
            {
                throw;
            }
             finally {
				
			}
             */
            return null;
        }
        #endregion

        #region Cherche une chaîne dans tous les fichiers d'un répertoire
        
        /// <summary>Cherche une chaîne dans tous les fichiers d'un répertoire</summary>
        /// <remarks>12/07/2008</remarks>
        /// <param name="strIndexCherche">Chaine recherchée</param>
        /// <param name="strChemin">Répertoire de recherche</param>
        /// <param name="strMasqueExtension">Extension des fichiers à traiter</param>
        /// <returns>nom du fichier trouvé, rien sinon</returns>
        
        public static string ChercheChaine( string strIndexCherche, string strChemin, string strMasqueExtension )
        {
            try
            {
                // lire les fichiers du repertoire
                string[] filenames = Directory.GetFiles( strChemin, strMasqueExtension );
                foreach ( string file in filenames )
                {
                    string name = Path.GetFileName( file );
                    string ligne = string.Empty;
                    using ( StreamReader srFichierATraiter = new StreamReader( file, System.Text.Encoding.Default, true, 65536 ) )
                    {
                        while ( ( ligne = srFichierATraiter.ReadLine() ) != null )
                        {
                            // verifier si chaine presente
                            if ( ligne.Contains( strIndexCherche ) )
                                // retour du nom de fichier
                                return name;
                        }
                    }

                }
                // index non trouvé ; on retourne le paramètre
                return string.Empty;
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {

            }
        }
        #endregion

        #region Récupérer une partie d'un fichier (ligne n à x)
        /// <summary>
        /// Récupérer une partie d'un fichier (ligne n à x)
        /// </summary>
        /// <param name="path"></param>
        /// <param name="StartMarkerLine"></param>
        /// <param name="EndMarkerLine"></param>
        /// <returns></returns>
        ///<example>GetFilePart(@"c:\mon_fichier.txt", 15, 20);</example>
        public static string GetPartOfTextFile( string path, uint start, uint end )
        {
            System.Text.StringBuilder szbTemp = new System.Text.StringBuilder();
            try
            {
                if ( start > end )
                {
                    Debug.WriteLine( "Erreur dans les marqueurs de lignes début et/ou fin." );
                    throw new ArgumentException( "Erreur dans les marqueurs de lignes début et/ou fin." );
                }
                if ( System.IO.File.Exists( path ) )
                {
                    using ( System.IO.FileStream fs = System.IO.File.OpenRead( path ) )
                    {
                        using ( System.IO.StreamReader sr = new System.IO.StreamReader( fs ) )
                        {
                            uint uiMarker = 0;
                            string sReadLine = string.Empty;
                            while ( sr.EndOfStream == false )
                            {
                                sReadLine = sr.ReadLine();
                                uiMarker += 1;
                                if ( ( start <= uiMarker ) && ( end >= uiMarker ) )
                                {
                                    szbTemp.AppendLine( sReadLine );
                                }
                                else if ( end < uiMarker )
                                {
                                    break;
                                }
                            }
                        }
                    }
                    return szbTemp.ToString();
                }
                else
                    return string.Empty;
            }
            catch ( Exception  )
            {
                throw;
            }
        }
        #endregion
    }
}
